home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / libs / intuisup.lha / Intuisup / source.lha / Borders / borders.c < prev    next >
C/C++ Source or Header  |  1992-04-08  |  7KB  |  257 lines
  1. /* $Revision Header *** Header built automatically - do not edit! ***********
  2.  *
  3.  *    (C) Copyright 1991 by Torsten Jürgeleit
  4.  *
  5.  *    Name .....: borders.c
  6.  *    Created ..: Thursday 19-Dec-91 17:25:52
  7.  *    Revision .: 1
  8.  *
  9.  *    Date        Author                 Comment
  10.  *    =========   ====================   ====================
  11.  *    24-Jan-92   Torsten Jürgeleit      new support function for
  12.  *                                         modify_gadget()
  13.  *    19-Dec-91   Torsten Jürgeleit      Created this file!
  14.  *
  15.  ****************************************************************************
  16.  *
  17.  *    Routines to draw borders with 3D look
  18.  *
  19.  * $Revision Header ********************************************************/
  20.  
  21.     /* Includes */
  22.  
  23. #include <exec/types.h>
  24. #include <intuition/intuition.h>
  25. #ifdef AZTEC_C
  26. #include <functions.h>   /* needed for Aztec C - prototypes and pragmas for all Amiga system functions */
  27. #endif
  28. #include <libraries/memwatch.h>   /* header file for memory debug link library (Fish 240) - AFTER functions.h */
  29. #include "/render/render.h"
  30. #include "borders.h"
  31.  
  32.     /* Defines */
  33.  
  34. #define MAX_BORDER_BUFFER_SIZE            BORDER_TYPE_BOX2_BUFFER_SIZE
  35.  
  36. #define BORDER_VEC_MODE_BOX_TOP_LEFT        0
  37. #define BORDER_VEC_MODE_BOX_BOTTOM_RIGHT    1
  38.  
  39.     /* Static prototypes */
  40.  
  41. VOID fill_border_vec(SHORT *vec, USHORT width, USHORT height, USHORT mode);
  42.  
  43.     /* Static pragmas */
  44.  
  45. #pragma regcall(fill_border_vec(a0,d0,d1,d2))
  46.  
  47.     /* Display borders described by border list */
  48.  
  49.    VOID
  50. display_borders(struct RenderInfo  *ri, struct Window  *win,
  51.                struct BorderData  *bd, SHORT hoffset, SHORT voffset)
  52. {
  53.    if (ri && win && bd) {
  54.       for ( ; bd->bd_Type != INTUISUP_DATA_END &&
  55.                 bd->bd_Type <= MAX_BORDER_DATA_TYPE; bd++) {
  56.      draw_border(ri, win, bd->bd_LeftEdge + hoffset, bd->bd_TopEdge +
  57.          voffset, bd->bd_Width, bd->bd_Height, (USHORT)bd->bd_Type);
  58.       }
  59.    }
  60. }
  61.     /* Draw border */
  62.  
  63.    VOID
  64. draw_border(struct RenderInfo  *ri, struct Window  *win, USHORT left_edge,
  65.           USHORT top_edge, USHORT width, USHORT height, USHORT type)
  66. {
  67.    if (ri && win) {
  68.       BYTE buffer[MAX_BORDER_BUFFER_SIZE];
  69.  
  70.       init_border(ri, &buffer[0], 0, 0, width, height, type);
  71.       if (ri->ri_Flags & RENDER_INFO_FLAG_INNER_WINDOW) {
  72.      left_edge += ri->ri_WindowBorderLeft;
  73.      top_edge  += ri->ri_WindowBorderTop;
  74.       }
  75.       DrawBorder(win->RPort, (struct Border *)&buffer[0], (LONG)left_edge,
  76.                                (LONG)top_edge);
  77.    }
  78. }
  79.     /* Init border - NON STATIC because needed for gadget routines too */
  80.  
  81.     BYTE *
  82. init_border(struct RenderInfo  *ri, BYTE *buffer, SHORT left_edge,
  83.            SHORT top_edge, USHORT width, USHORT height, USHORT type)
  84. {
  85.    struct Border  *border = (struct Border *)buffer;
  86.    UBYTE  highlight_pen, shadow_pen;
  87.    SHORT  *vec;
  88.    USHORT i, vec_mode, vec_width, vec_height;
  89.  
  90.    switch (type) {
  91.       case BORDER_DATA_TYPE_BOX1_OUT :
  92.       case BORDER_DATA_TYPE_BOX2_OUT :
  93.      highlight_pen = ri->ri_HighlightPen;
  94.      shadow_pen    = ri->ri_ShadowPen;
  95.      break;
  96.  
  97.       case BORDER_DATA_TYPE_BOX1_IN :
  98.       case BORDER_DATA_TYPE_BOX2_IN :
  99.      highlight_pen = ri->ri_ShadowPen;
  100.      shadow_pen    = ri->ri_HighlightPen;
  101.      break;
  102.    }
  103.    switch (type) {
  104.       case BORDER_DATA_TYPE_BOX1_OUT :
  105.       case BORDER_DATA_TYPE_BOX1_IN :
  106.      vec = (SHORT *)(border + 2);
  107.      for (i = 0; i < 2; i++, border++, vec += 10) {
  108.         if (i & 1) {   /* odd ? */
  109.            border->FrontPen = shadow_pen;
  110.            vec_mode         = BORDER_VEC_MODE_BOX_BOTTOM_RIGHT;
  111.         } else {
  112.            border->FrontPen = highlight_pen;
  113.            vec_mode         = BORDER_VEC_MODE_BOX_TOP_LEFT;
  114.         }
  115.         border->LeftEdge = left_edge;
  116.         border->TopEdge  = top_edge;
  117.         border->DrawMode = JAM1;
  118.         border->Count    = 5;
  119.         border->XY       = vec;
  120.         if (i < 1) {
  121.            border->NextBorder = border + 1;
  122.         } else {
  123.            border->NextBorder = NULL;
  124.         }
  125.         fill_border_vec(vec, width, height, vec_mode);
  126.      }
  127.      buffer += BORDER_TYPE_BOX1_BUFFER_SIZE;
  128.      break;
  129.  
  130.       case BORDER_DATA_TYPE_BOX2_OUT :
  131.       case BORDER_DATA_TYPE_BOX2_IN :
  132.      vec = (SHORT *)(border + 4);
  133.      for (i = 0; i < 4; i++, border++, vec += 10) {
  134.         if (i < 2) {
  135.            border->LeftEdge = left_edge;
  136.            border->TopEdge  = top_edge;
  137.            if (i & 1) {   /* odd ? */
  138.           border->FrontPen = shadow_pen;
  139.           vec_mode         = BORDER_VEC_MODE_BOX_BOTTOM_RIGHT;
  140.            } else {
  141.           border->FrontPen = highlight_pen;
  142.           vec_mode         = BORDER_VEC_MODE_BOX_TOP_LEFT;
  143.            }
  144.            vec_width  = width;
  145.            vec_height = height;
  146.         } else {
  147.            border->LeftEdge = left_edge + 2;
  148.            border->TopEdge  = top_edge + 1;
  149.            if (i & 1) {   /* odd ? */
  150.           border->FrontPen = highlight_pen;
  151.           vec_mode         = BORDER_VEC_MODE_BOX_BOTTOM_RIGHT;
  152.            } else {
  153.           border->FrontPen = shadow_pen;
  154.           vec_mode         = BORDER_VEC_MODE_BOX_TOP_LEFT;
  155.            }
  156.            vec_width  = width - 4;
  157.            vec_height = height - 2;
  158.         }
  159.         border->DrawMode = JAM1;
  160.         border->Count    = 5;
  161.         border->XY       = vec;
  162.         if (i < 3) {
  163.            border->NextBorder = border + 1;
  164.         } else {
  165.            border->NextBorder = NULL;
  166.         }
  167.         fill_border_vec(vec, vec_width, vec_height, vec_mode);
  168.      }
  169.      buffer += BORDER_TYPE_BOX2_BUFFER_SIZE;
  170.      break;
  171.    }
  172.    return(buffer);
  173. }
  174.     /* Resize border - NON STATIC because needed for gadget routines */
  175.  
  176.     VOID
  177. resize_border(struct Border  *border, USHORT width, USHORT height,
  178.                                 USHORT type)
  179. {
  180.    USHORT i;
  181.  
  182.    switch (type) {
  183.       case BORDER_DATA_TYPE_BOX1_OUT :
  184.       case BORDER_DATA_TYPE_BOX1_IN :
  185.      for (i = 0; border; i++, border = border->NextBorder) {
  186.         USHORT vec_mode;
  187.  
  188.         if (i & 1) {   /* odd ? */
  189.            vec_mode = BORDER_VEC_MODE_BOX_BOTTOM_RIGHT;
  190.         } else {
  191.            vec_mode = BORDER_VEC_MODE_BOX_TOP_LEFT;
  192.         }
  193.         fill_border_vec(border->XY, width, height, vec_mode);
  194.      }
  195.      break;
  196.  
  197.       case BORDER_DATA_TYPE_BOX2_OUT :
  198.       case BORDER_DATA_TYPE_BOX2_IN :
  199.      for (i = 0; border; i++, border = border->NextBorder) {
  200.         USHORT vec_mode, vec_width, vec_height;
  201.  
  202.         if (i < 2) {
  203.            if (i & 1) {   /* odd ? */
  204.           vec_mode = BORDER_VEC_MODE_BOX_BOTTOM_RIGHT;
  205.            } else {
  206.           vec_mode = BORDER_VEC_MODE_BOX_TOP_LEFT;
  207.            }
  208.            vec_width  = width;
  209.            vec_height = height;
  210.         } else {
  211.            if (i & 1) {   /* odd ? */
  212.           vec_mode = BORDER_VEC_MODE_BOX_BOTTOM_RIGHT;
  213.            } else {
  214.           vec_mode = BORDER_VEC_MODE_BOX_TOP_LEFT;
  215.            }
  216.            vec_width  = width - 4;
  217.            vec_height = height - 2;
  218.         }
  219.         fill_border_vec(border->XY, vec_width, vec_height, vec_mode);
  220.      }
  221.      break;
  222.    }
  223. }
  224.     /* Fill border vector */
  225.  
  226.    STATIC VOID
  227. fill_border_vec(SHORT *vec, USHORT width, USHORT height, USHORT mode)
  228. {
  229.    switch (mode) {
  230.       case BORDER_VEC_MODE_BOX_TOP_LEFT :
  231.      *(vec++) = width - 2;
  232.      *(vec++) = 0;
  233.      *(vec++) = 0;
  234.      *(vec++) = 0;
  235.      *(vec++) = 0;
  236.      *(vec++) = height - 1;
  237.      *(vec++) = 1;
  238.      *(vec++) = height - 2;
  239.      *(vec++) = 1;
  240.      *(vec)   = 1;
  241.      break;
  242.  
  243.       case BORDER_VEC_MODE_BOX_BOTTOM_RIGHT :
  244.      *(vec++) = 1;
  245.      *(vec++) = height - 1;
  246.      *(vec++) = width - 1;
  247.      *(vec++) = height - 1;
  248.      *(vec++) = width - 1;
  249.      *(vec++) = 0;
  250.      *(vec++) = width - 2;
  251.      *(vec++) = 1;
  252.      *(vec++) = width - 2;
  253.      *(vec)   = height - 2;
  254.      break;
  255.    }
  256. }
  257.